<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
  <div>
    <h2>一、是什么</h2>
    <div>闭包就是在一个函数内部创建另一个函数，让你可以在一个内层函数中访问到其外层函数的作用域。又或者说，闭包就是能够读取其他函数内部变量的函数。
      <br>
      在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
    </div>
  </div>
  <script>
  // 简单的例子
  function init() {
    var name = "Mozilla"; // name 是一个被 init 创建的局部变量
    function displayName() { // displayName() 是内部函数，一个闭包
        alert(name); // 使用了父函数中声明的变量
    }
    displayName();
  }
  init();
  </script>
  <div>
    <h2>二、使用场景</h2>
    <h4>任何闭包的使用场景都离不开这两点：</h4>
    <ul>
      <li>创建私有变量</li>
      <li>延长变量的生命周期</li>
    </ul>
    <button id="size-12">size-12</button>
    <button id="size-14">size-14</button>
    <button id="size-16">size-16</button>
  </div>
  <script>
    function makeSizer(size) {
      return function() {
        document.body.style.fontSize = size + 'px';
      };
    }

    var size12 = makeSizer(12);
    var size14 = makeSizer(14);
    var size16 = makeSizer(16);

    document.getElementById('size-12').onclick = size12;
    document.getElementById('size-14').onclick = size14;
    document.getElementById('size-16').onclick = size16;



    // 柯里化函数:柯里化的目的在于避免频繁调用具有相同参数函数的同时，又能够轻松的重用
    // 假设我们有一个求长方形面积的函数
    function getArea(width, height) {
        return width * height
    }
    // 如果我们碰到的长方形的宽老是10
    const area1 = getArea(10, 20)
    const area2 = getArea(10, 30)
    const area3 = getArea(10, 40)

    // 我们可以使用闭包柯里化这个计算面积的函数
    function getArea(width) {
        return height => {
            return width * height
        }
    }

    const getTenWidthArea = getArea(10)
    // 而且如果遇到宽度偶尔变化也可以轻松复用
    const getTwentyWidthArea = getArea(20)
  </script>


  <script>
      var Counter = (function() {
      var privateCounter = 0;
      function changeBy(val) {
        privateCounter += val;
      }
      return {
        increment: function() {
          changeBy(1);
        },
        decrement: function() {
          changeBy(-1);
        },
        value: function() {
          return privateCounter;
        }
      }
    })();

    // var Counter1 = makeCounter();
    // var Counter2 = makeCounter();
    // console.log(Counter1.value()); /* logs 0 */
    // Counter1.increment();
    // Counter1.increment();
    // console.log(Counter1.value()); /* logs 2 */
    // Counter1.decrement();
    // console.log(Counter1.value()); /* logs 1 */
    // console.log(Counter2.value()); /* logs 0 */
  </script>
  <div>
    <h2>其他</h2>
    <div>例如计数器、延迟调用、回调等闭包的应用，其核心思想还是创建私有变量和延长变量的生命周期</div>
  </div>
  <div>
    <h2>三、注意事项</h2>
    <div>如果不是某些特定任务需要使用闭包，在其它函数中创建函数是不明智的，因为闭包在处理速度和内存消耗方面对脚本性能具有负面影响
      <br>
      例如，在创建新的对象或者类时，方法通常应该关联于对象的原型，而不是定义到对象的构造器中。
      <br>
      原因在于每个对象的创建，方法都会被重新赋值
    </div>
  </div>
  <script>

    {
      // 块级作用域中的变量
      let greeting = 'Hello World!';
      var lang = 'English';
      console.log(greeting); // Prints 'Hello World!'
    }
    console.log(lang);// 变量 'English'
    console.log(greeting);// 报错：Uncaught ReferenceError: greeting is not defined
  </script>
</body>

</html>